package com.innovations.inn.service.impl;

import com.innovations.common.core.domain.entity.SysRole;
import com.innovations.common.utils.DateUtils;
import static com.innovations.common.utils.MyBeanUtils.copyProperties;
import com.innovations.common.utils.StringUtils;
import com.innovations.common.utils.uuid.IdGeneratorSnowflake;
import com.innovations.inn.domain.Enterprise;
import com.innovations.inn.domain.EnterpriseQualification;
import com.innovations.inn.domain.request.RequestEnterpriseInfoAll;
import com.innovations.inn.domain.response.ResponseEnterpriseInfo;
import com.innovations.inn.domain.response.ResponseEnterpriseInfoAll;
import com.innovations.inn.mapper.EnterpriseMapper;
import com.innovations.inn.service.IEnterpriseQualificationService;
import com.innovations.inn.service.IEnterpriseService;
import com.innovations.system.service.ISysRoleService;
import com.innovations.system.service.ISysUserService;
import java.beans.Transient;
import java.util.Arrays;
import java.util.List;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * 企业信息Service业务层处理
 *
 * @author dp
 * @date 2024-08-09
 */
@Slf4j
@Service
public class EnterpriseServiceImpl implements IEnterpriseService {
    @Autowired
    IdGeneratorSnowflake idGeneratorSnowflake;
    @Autowired
    private EnterpriseMapper enterpriseMapper;
    @Autowired
    private ISysUserService userService;
    @Autowired
    private ISysRoleService roleService;
    @Autowired
    private IEnterpriseQualificationService enterpriseQualificationService;

    /**
     * 查询企业信息
     *
     * @param enterpriseId 企业信息主键
     * @return 企业信息
     */
    @Override
    public Enterprise selectEnterpriseByEnterpriseId(Long enterpriseId) {
        return enterpriseMapper.selectEnterpriseByEnterpriseId(enterpriseId);
    }

    /**
     * 查询企业信息列表
     *
     * @param enterprise 企业信息
     * @return 企业信息
     */
    @Override
    public List<Enterprise> selectEnterpriseList(Enterprise enterprise) {
        return enterpriseMapper.selectEnterpriseList(enterprise);
    }

    /**
     * 查询企业信息详细列表
     */
    @Override
    public List<ResponseEnterpriseInfo> selectEnterpriseListInfo(Enterprise enterprise) {
        return enterpriseMapper.selectEnterpriseListInfo(enterprise);
    }

    /**
     * 查询企业及资质详细信息列表
     */
    @Override
    public List<ResponseEnterpriseInfoAll> selectEnterpriseListInfoAll(Enterprise enterprise) {
        return enterpriseMapper.selectEnterpriseListInfoAll(enterprise);
    }

    /**
     * 新增企业信息
     *
     * @param enterprise 企业信息
     * @return 结果
     */
    @Override
    public int insertEnterprise(Enterprise enterprise) {
        // 状态为审核通过时，添加商业角色
        if (enterprise.getState() == 2) {
            List<SysRole> roles = roleService.selectRolesByUserId(enterprise.getUserId());
            Long[] roleIds = roles.stream().filter(SysRole::isFlag).map(SysRole::getRoleId).toArray(Long[]::new);
            // 判断角色列表中是否有企业用户角色（5）
            if (Arrays.stream(roleIds).noneMatch(roleId -> roleId == 5L)) {
                // 添加商业用户角色
                Long[] roleId = new Long[]{5L};
                userService.insertUserAuth(enterprise.getUserId(), roleId);
            }
        }
        return enterpriseMapper.insertEnterprise(enterprise);
    }

    /**
     * 新增企业及资质信息
     *
     * @param input 企业及资质信息
     * @return 结果
     */
    @Override
    @Transient
    public int insertEnterpriseAll(RequestEnterpriseInfoAll input) {
        try {
            input.setCreateBy(input.getUserId());
            input.setEnterpriseId(idGeneratorSnowflake.nextId());
            input.setEnterpriseQualificationId(idGeneratorSnowflake.nextId());
            input.setCreateTime(DateUtils.getNowDate());

            // 新增企业信息
            Enterprise enterprise = copyProperties(input, Enterprise.class);
            enterpriseMapper.insertEnterprise(enterprise);
            // 新增企业资质信息
            EnterpriseQualification enterpriseQualification = copyProperties(input, EnterpriseQualification.class);
            enterpriseQualificationService.insertEnterpriseQualification(enterpriseQualification);
        } catch (Exception e) {
            log.error("新增企业信息失败", e);
            return 0;
        }
        return 1;
    }

    /**
     * 修改企业信息
     *
     * @param enterprise 企业信息
     * @return 结果
     */
    @Override
    public int updateEnterprise(Enterprise enterprise) {
        // 状态为审核通过时，添加商业角色
        if (enterprise.getState() == 2) {
            List<SysRole> roles = roleService.selectRolesByUserId(enterprise.getUserId());
            Long[] roleIds = roles.stream().filter(SysRole::isFlag).map(SysRole::getRoleId).toArray(Long[]::new);
            // 判断角色列表中是否有企业用户角色（5）
            if (Arrays.stream(roleIds).noneMatch(roleId -> roleId == 5L)) {
                // 添加商业用户角色
                Long[] roleId = new Long[]{5L};
                userService.insertUserAuth(enterprise.getUserId(), roleId);
            }
        }
        // 状态为拒绝时，需填写拒审原因
        if (enterprise.getState() == 3 && StringUtils.isBlank(enterprise.getRefusalReason())) {
            throw new RuntimeException("请填写拒审原因");
        }
        return enterpriseMapper.updateEnterprise(enterprise);
    }

    /**
     * 批量删除企业信息
     *
     * @param enterpriseIds 需要删除的企业信息主键
     * @return 结果
     */
    @Override
    public int deleteEnterpriseByEnterpriseIds(Long[] enterpriseIds) {
        return enterpriseMapper.deleteEnterpriseByEnterpriseIds(enterpriseIds);
    }

    /**
     * 删除企业信息信息
     *
     * @param enterpriseId 企业信息主键
     * @return 结果
     */
    @Override
    public int deleteEnterpriseByEnterpriseId(Long enterpriseId) {
        return enterpriseMapper.deleteEnterpriseByEnterpriseId(enterpriseId);
    }

    /**
     * 实体数据补全
     *
     * @param enterprise 实体
     * @param userId     用户id
     * @param crateType  创建类型 1：新增 2：修改
     */
    @Override
    public void completeData(Enterprise enterprise, Long userId, Integer crateType) {
        // 主键
        if (enterprise.getEnterpriseId() == null || "".equals(enterprise.getEnterpriseId())) {
            enterprise.setEnterpriseId(idGeneratorSnowflake.nextId());
        }
        // 创建模式
        if (crateType == 1) {
            // 创建人
            if (enterprise.getUserId() == null) {
                enterprise.setUserId(userId);
            }
            // （企业）状态:0.创建 1.提交 2.审核 3.拒审
            if (enterprise.getState() == null) {
                enterprise.setState(0L);
            }
        }
        // 修改模式
        else if (crateType == 2) {
            // 判断如果为【2】审核状态，且未审核过，则添加审核人、审核时间
            if (enterprise.getState() == 2 && enterprise.getAuditBy() == null) {
                enterprise.setAuditBy(userId);
                enterprise.setAuditTime(DateUtils.getNowDate());
            }
        }
//        // 逻辑删除
//        if (enterprise.getIsDeleted() == null || "".equals(enterprise.getIsDeleted())) {
//            enterprise.setIsDeleted(0L);
//        }
    }
}
